Method for scheduling entity in multicore processor system

ABSTRACT

The embodiments herein provide a method for scheduling an entity in a multi-core processor system including a big-core processor, and a little-core processor. The method includes detecting, by a scheduler, that a load contribution of the entity exceeds a load threshold. Further, the method includes determining, by the scheduler, whether the entity is one of a background entity, an IO intensive entity, a non-background entity, and a non-IO intensive entity based on at least one parameter. Further, the method includes instructing, by the scheduler, one of to schedule the entity on a little-core processor when the entity is at least one of the background entity and the IO intensive entity; and to schedule the entity on the big-core processor when the entity is at least one of the non-background entity and the non-IO intensive entity.

TECHNICAL FIELD

The embodiments herein generally relate to scheduling mechanisms. Moreparticularly, related to a mechanism for scheduling an entity in amulti-core processor system. The present application is based on, andclaims priority from an Indian Application Number 2761/CHE/2015 filed on1 Jun. 2015, the disclosure of which is hereby incorporated by referenceherein.

BACKGROUND ART

The rise of smart phones has been phenomenal in the last decade. Theyhave come a long way from merely a two way radio to an electronic devicethat keeps you connected to all the information throughout the day. Thedemand for performance has hence been increasing at a much faster ratethan the corresponding improvements in a battery technology. The demandfor higher performance is thus in direct conflict with the battery lifeof the smart phone and this has in turn led to a lot of innovation inthe field of power management. This includes a lot of advanced powermanagement features built into an Operating System (OS) itself alongwith advancements in display technology like active-matrix organiclight-emitting diode (AMOLED). This eventually led to a silicon on chip(SoC) design, where the processing of the performance-intensivepower-hungry “big” cores are coupled with a power-saving “LITTLE” coresin the same system joined by a cache coherent interconnect fabric. Thisarchitecture is called a big.LITTLE™ architecture.

The Completely Fair scheduler (CFS) is a task based scheduler in Linuxoperating system. The CFS schedules the entities on cores based on theexecution history of the entities. The Task scheduler was notintrinsically built to take advantage of a Heterogeneous Multiprocessing(HMP) System like big.LITTLE™ architecture but was designed for aSymmetric Multiprocessing (SMP) System. This led to a set of patchesthat added information regarding the per-entity utilization of a core tothe CFS.

The CFS algorithm primarily tracks the amount of time that a schedulingentity has run on a virtualized ideal multi-tasking processor. If aparticular scheduling entity has run for a lesser virtual time than theentity that is currently executing on the processor, the fairness of thesystem is not maintained anymore. Hence, the entity that is currentlyrunning is pre-empted by the entity that has run for a lesser amount oftime to maintain fairness. This system works efficiently for the SMPsystem as all the cores are equal and the Scheduler can treat them asthe same. However, this does not hold good for the HMP system. In thecurrent HMP implementation, a scheduling entity is classified as a bigor a small entity based on its execution history calculated by any ofper-entity Load tracking method and Window based tracking. When the loaddetermined form this execution history exceeds a predefined threshold,the corresponding entity is categorized as a big entity or otherwise asa small entity. This is then placed on the big or little clustercorrespondingly.

In the conventional systems and methods, the task scheduling is based onthe load history of the task. If the load contribution of the entityexceeds a predefined load threshold, then the task is scheduled on thebig cores irrespective of the characteristic of the task. Thiseventually affects the user experience and the battery life of thesystem. In an example, if the task is a background task which does notneed the additional processing power of the big cores, may be scheduledon the big cores when the the load contribution of the entity exceeds apredefined load threshold. This increases the power consumption of theelectronic device as the big cores are performance intensive.

DISCLOSURE OF INVENTION Solution to Problem

Accordingly the embodiments herein provide a method for scheduling anentity in a multi-core processor system including a big-core processor,and a little-core processor. The method includes detecting, by ascheduler, that a load contribution of the entity exceeds a loadthreshold. Further, the method includes determining, by the scheduler,whether the entity is one of a background entity, an IO intensiveentity, a non-background entity, and a non-IO intensive entity based onat least one parameter. Further, the method includes instructing, by thescheduler, one of to schedule the entity on a little-core processor whenthe entity is at least one of the background entity and the IO intensiveentity; and to schedule the entity on the big-core processor when theentity is at least one of the non-background entity and the non-IOintensive entity.

Advantageous Effects of Invention

Accordingly the embodiments herein provide a method for scheduling anentity in a multi-core processor system including a big-core processor,and a little-core processor.

BRIEF DESCRIPTION OF DRAWINGS

This invention is illustrated in the accompanying drawings, throughoutwhich like reference letters indicate corresponding parts in the variousfigures. The embodiments herein will be better understood from thefollowing description with reference to the drawings, in which:

FIG. 1 illustrates various units of an electronic device for schedulingan entity in a multi-core processor system including a big-coreprocessor, and a little-core processor, according to an embodiment asdisclosed herein;

FIG. 2a illustrates a communication flow between a multi-core processorsystem and a scheduler for determining whether the entity is one of abackground entity and a non-background entity, according to anembodiment as disclosed herein;

FIG. 2b illustrates a communication flow between the multi-coreprocessor system and the scheduler for determining whether the entity isone of an IO intensive entity and a non-IO intensive entity, accordingto an embodiment as disclosed herein;

FIG. 3 is a flow diagram illustrating a method for scheduling the entityin the multi-core processor system including the big-core processor, andthe little-core processor, according to an embodiment as disclosedherein;

FIG. 4 is a flow diagram illustrating a method for determining whetherthe entity is one of the background entity, the IO intensive entity, thenon-background entity, and the non-IO intensive entity, according to anembodiment as disclosed herein; and

FIG. 5 illustrates a computing environment implementing the method andsystem for scheduling the entity in the multi-core processor systemincluding the big-core processor, and the little-core processor,according to an embodiment as disclosed herein.

BEST MODE FOR CARRYING OUT THE INVENTION

Accordingly the embodiments herein provide a method for scheduling anentity in a multi-core processor system including a big-core processor,and a little-core processor. The method includes detecting, by ascheduler, that a load contribution of the entity exceeds a loadthreshold. Further, the method includes determining, by the scheduler,whether the entity is one of a background entity, an IO intensiveentity, a non-background entity, and a non-IO intensive entity based onat least one parameter. Further, the method includes instructing, by thescheduler, one of to schedule the entity on a little-core processor whenthe entity is at least one of the background entity and the IO intensiveentity; and to schedule the entity on the big-core processor when theentity is at least one of the non-background entity and the non-IOintensive entity.

Accordingly the embodiments herein provide an electronic device forscheduling an entity in a multi-core processor system including abig-core processor, and a little-core processor. The electronic deviceincludes a memory, a processor coupled to the memory, and a schedulercoupled to the processor. Further, the scheduler is configured to detectthat a load contribution of the entity exceeds a load threshold.Further, the scheduler is configured to determine whether the entity isone of a background entity, an IO intensive entity, a non-backgroundentity, and a non-IO intensive entity based on at least one parameter.Further, the scheduler is configured to instruct one of to schedule theentity on a little-core processor when the entity is at least one of thebackground entity and the IO intensive entity; and to schedule theentity on the big-core processor when the entity is at least one of thenon-background entity and the non-IO intensive entity.

Accordingly the embodiments herein provide a computer program productcomprising computer executable program code recorded on a computerreadable non-transitory storage medium. The computer executable programcode when executed causing the actions including detecting, by ascheduler, that a load contribution of an entity exceeds a loadthreshold. Further, the computer executable program code when executedcausing the actions including determining, by the scheduler, whether theentity is one of a background entity, an IO intensive entity, anon-background entity, and a non-IO intensive entity based on at leastone parameter. Further, the computer executable program code whenexecuted causing the actions including instructing, by the scheduler,one of to schedule the entity on a little-core processor when the entityis at least one of the background entity and the IO intensive entity;and to schedule the entity on the big-core processor when the entity isat least one of the non-background entity and the non-IO intensiveentity.

These and other aspects of the embodiments herein will be betterappreciated and understood when considered in conjunction with thefollowing description and the accompanying drawings. It should beunderstood, however, that the following descriptions, while indicatingpreferred embodiments and numerous specific details thereof, are givenby way of illustration and not of limitation. Many changes andmodifications may be made within the scope of the embodiments hereinwithout departing from the spirit thereof, and the embodiments hereininclude all such modifications.

MODE FOR THE INVENTION

The principal object of the embodiments herein is to provide a mechanismfor scheduling an entity in a heterogeneous multi-core processor systemsuch as a big.LITTLE™ architecture based processor system.

Another object of the embodiments herein is to provide a mechanism fordetecting whether a load contribution of the entity exceeds a loadthreshold.

Another object of the embodiments herein is to provide a mechanism fordetermining whether the entity is one of a background entity, an IOintensive entity, a non-background entity, and a non-IO intensive entitybased on at least one parameter.

Another object of the embodiments herein is to provide a mechanism forinstructing one of to schedule the entity on the little-core processorwhen the entity is at least one of the background entity and the IOintensive entity; and to schedule the entity on the big-core processorwhen the entity is at least one of the non-background entity and thenon-IO intensive entity.

The embodiments herein and the various features and advantageous detailsthereof are explained more fully with reference to the non-limitingembodiments that are illustrated in the accompanying drawings anddetailed in the following description. Descriptions of well-knowncomponents and processing techniques are omitted so as to notunnecessarily obscure the embodiments herein. Also, the variousembodiments described herein are not necessarily mutually exclusive, assome embodiments can be combined with one or more other embodiments toform new embodiments. The term “or” as used herein, refers to anon-exclusive or, unless otherwise indicated. The examples used hereinare intended merely to facilitate an understanding of ways in which theembodiments herein can be practiced and to further enable those skilledin the art to practice the embodiments herein. Accordingly, the examplesshould not be construed as limiting the scope of the embodiments herein.

The embodiments herein disclose a method for scheduling an entity in amulti-core processor system including a big-core processor, and alittle-core processor. The method includes detecting that a loadcontribution of the entity exceeds a load threshold. Further, the methodincludes determining whether the entity is one of a background entity,an Input-Output (IO) intensive entity, a non-background entity, and anon-IO intensive entity based on at least one parameter. Further, themethod includes instructing one of to schedule the entity on thelittle-core processor when the entity is at least one of the backgroundentity, and the IO intensive entity; and to schedule the entity on thebig-core processor when the entity is at least one of the non-backgroundentity and the non-IO intensive entity.

In an embodiment, the parameter includes an Out-of-Memory (OOM) Score,an IO Turn-Around-Time, an amount of time that the entity is performingIO task in a pre-defined time period, a total execution time of theentity in the pre-defined time period, or combination of same.

In an embodiment, the background entity is one of a periodic task and aperiod service without user intervention.

In the conventional systems and methods, the entity is scheduled in themulti-core processor system based on the load contribution of theentity. If the load contribution of the entity exceeds the loadthreshold, then the task is scheduled on the big-core processorirrespective of the characteristic of the task. For example, thebackground entity does not need additional processing power of thebig-core processor. If the load contribution of the background entityexceeds the load threshold then, the background entity may be scheduledon the big-core processor. Thus, affecting the power consumption of theelectronic device as the big-core processors are performance intensive.

Unlike the conventional systems and methods, the proposed mechanismprovides a power efficient scheduler design without impacting theperformance of an electronic device that includes the multi-coreprocessor system. Further, the proposed method provides a mechanism forimproving the power consumption of the electronic device by dividingperformance intensive entities between the big-core processor (in caseof the non-background entity exceeding the load threshold) and thelittle-core processor (in case of the background entity exceeding theload threshold). The background entity is scheduled on the little-coreprocessor even though its immediate load might be high, thus loweringthe migration cost and resulting in better power consumption of theelectronic device without impacting the performance.

Unlike the conventional systems and methods, the proposed mechanismavoids migration of the background entity from the little-core processorto the big-core processor even though the load contribution of thebackground entity exceeding the load threshold.

Referring now to the drawings, and more particularly to FIGS. 1 through5, where similar reference characters denote corresponding featuresconsistently throughout the figures, there are shown preferredembodiments.

FIG. 1 illustrates various units of an electronic device 100 forscheduling the entity in a multi-core processor system 104 including abig-core processor 104 a, and a little-core processor 104 b, accordingto an embodiment as disclosed herein. In an embodiment, the electronicdevice 100 includes a scheduler unit 102, a multi-core processor system104, a storage unit 106, and a communication unit 108. The multi-coreprocessor system 104 includes a Big-core processor 104 a and aLittle-core processor 104 b. The electronic device 100 may be a mobilephone, a smart phone, Personal Digital Assistants (PDAs), a tablet, aphablet, consumer electronic device, dual display devices, or any otherelectronic devices. In an embodiment, the entity may be a task, athread, a data flow, or the like.

In an embodiment, the scheduler unit 102 detects that a loadcontribution of the entity exceeds a load threshold. Further, thescheduler unit 102 can be configured to determine whether the entity isa background entity, an Input-Output (IO) intensive entity, anon-background entity, or a non-IO intensive entity based on at leastone parameter. In an embodiment, the parameter includes an Out-of-Memory(OOM) Score, an IO Turn-Around-Time, amount of time that the entity isperforming IO task in the pre-defined time period, total execution timeof the entity in the pre-defined time period, or combination of same.Further, the scheduler unit 102 can be configured to instruct themulti-core processor system 104 to schedule the entity on thelittle-core processor 104 b when the entity is the background entity orthe IO intensive entity. Furthermore, the scheduler unit 102 can beconfigured to instruct the multi-core processor system 104 to schedulethe entity on the big-core processor 104 a when the entity is thenon-background entity or the non-IO intensive entity.

Further, the storage unit 106 may include one or more computer-readablestorage media. The storage unit 106 may include non-volatile storageelements. Examples of such non-volatile storage elements may includemagnetic hard discs, optical discs, floppy discs, flash memories, orforms of electrically programmable memories (EPROM) or electricallyerasable and programmable (EEPROM) memories. In addition, the storageunit 106 may, in some examples, be considered a non-transitory storagemedium. The term “non-transitory” may indicate that the storage mediumis not embodied in a carrier wave or a propagated signal. However, theterm “non-transitory” should not be interpreted that the storage unit106 is non-movable. In some examples, the storage unit 106 can beconfigured to store larger amounts of information than the memory. Incertain examples, a non-transitory storage medium may store data thatcan, over time, change (e.g., in Random Access Memory (RAM) or cache).The communication unit 108 can be configured for communicatinginternally between the units and externally with the networks.

In the conventional systems and methods, execution history of thescheduling entity is considered when scheduling the entity in either thebig-core processor 104 a or the little-core processor 104 b. When theload is above a certain threshold the scheduling entity is consideredbig and is scheduled on the big-core processor 104 a. All other entitiesare placed in the little-core processor 104 b. Further, this scheme canhence schedule background entities, which do not need the additionalprocessing power on the big-core processor 104 a, on the big-coreprocessor 104 a due to spurious bursts in the load of the task. Thiswill increase the power consumption of the electronic device 100 whilenot providing any benefits to the user experience.

Unlike the conventional mechanisms, the proposed mechanism is used toschedule the entities based on the entity being either the backgroundentity or the IO intensive entity and hence scheduling the entity oncertain cores based on these additional characteristics. The additionaltransient characteristics were primarily used in the core processorselection for the big.LITTLE architecture. Thus, leading to a moreenergy efficient scheduler design whilst not impacting the performanceof the electronic device 100.

The FIG. 1 shows a limited overview of the electronic device 100 but, itis to be understood that other embodiments are not limited thereto.Further, the electronic device 100 can include any number of units alongwith other hardware or software components communicating with eachother.

FIG. 2a illustrates a communication flow between the multi-coreprocessor system 104 and the scheduler unit 102 for determining whetherthe entity is the background entity or the non-background entity,according to an embodiment as disclosed herein.

In an embodiment, the scheduler unit 102 includes Run Queue unit 206, —aLoad Calculation unit 208, a Load Balance unit 210, an Idle Task unit212, a Core selection unit 214, a platform OOM value unit 216, an OOMTranslation unit 218, an Update Task Statistics unit 220, a Task Tickunit 222, a Cluster Selection unit 224, a Per-Task CPU Utilization unit226, a CPU metadata unit 228, an Interrupt request (IRQ) 230, and aReal-time clock (RTC) 232.

In an embodiment, the Run Queue unit 206 tracks runnable tasks (e.g.,entities) for a given core (i.e., either the big-core processor 104 a orthe little-core processor 104 b). In an embodiment, the load calculationunit 208 tracks load per entity and load per run queue in the schedulerunit 102. In an embodiment, the load balance unit 210 balances loadacross the multi-core processor system 104 including the big-coreprocessor 104 a, and the little-core processor 104 b. In an embodiment,the idle task unit 212 tracks an ideal entity. In an embodiment, thecore selection unit 214 selects a core (i.e., either the big-coreprocessor 104 a or the little-core processor 104 b) to schedule theentity in the multi-core processor system 104 including the big-coreprocessor 104 a, and the little-core processor 104 b. In an embodiment,the cluster selection unit 224 selects either the big-core processor 104a or the little-core processor 104 b in the multi-core processor system104 for scheduling the entity. In an embodiment, the OOM Translationunit 218 is configured to translate OOM score to a schedulerunderstandable format. In an embodiment, the CPU metadata unit 228tracts CPU utilization or CPU performance.

In an embodiment, the Per-Task CPU Utilization unit 226 tracks the CPUutilization by the entity. In an embodiment, the update task statisticsunit 220 updates statistics related to scheduling the entity into thescheduler unit 102. In an embodiment, the task tick unit 222 tracks anumber of times the entity is scheduled in the multi-core processorsystem 104. In an example, consider a scenario where the proposedmechanism is configured to schedule the entity from the Run Queue unit206 in the multi-core processor system 104.

Further, the load calculation unit 208 tracks the load of the entity andcompare with a load threshold (i.e., detecting that the loadcontribution of the entity exceeds the load threshold). If it is trackedthat the load contribution of the entity does not exceed the loadthreshold, then the idle task unit 212 checks whether the entity is theidle or the entity is not the idle entity. If the entity is the idle,then the scheduler unit 102 considers the entity as low priority forscheduling. If the entity is not the idle and the load contribution ofthe entity does not exceed the load threshold, then the core selectionunit 214 selects the Little-core processor 104 b for scheduling theentity. If it is tracked that the load contribution of the entityexceeds the load threshold, then the scheduler unit 102 is configured todetect whether the entity is the background entity or the non-backgroundentity based on the OOM score of the entity from the Platform OOM valueunit 216.

For example, Linux kernel, the OOM score of the entity is used toprioritize terminating of certain entities over other entities when pageallocation fails in the slow-path. Further, the OOM score is also usedby any platform to categorize and hence terminate the entities thosehave minimum contribution towards user experience when the system memoryfalls below a predefined threshold. For example, the platform may be anoperating system of the electronic device 100. The categorization of theentities is from lowest value entities to highest value entities. Thelowest OOM score is assigned only for native entities and highest valueis assigned for the entities, whose OOM score is yet to be calculated.The entities assigned with higher OOM score are terminated first whenthe system runs out of memory. The OOM scores that are used by theplatform categorize the entities based on characteristics of theentities. This is used by the scheduler unit 102 to categorize theentity as either the background entity or the non-background entity.

In an embodiment, the OOM scores that are used by the platform tocategorize the entities may be computed as shown in equation (1).

S _(platform) =S _(kernel)*(−OOM _(disable))/OOM _(max)  (1)

Where, S_(kernel) is the OMM score of an operating system kernel,S_(platform) is the OMM score used in the operating system of theelectronic device 100, OOM_(disable) is highest allowed OOM score,OOM_(max) is highest OOM score.

The S_(platform) value from the equation (1) is used as an input to thescheduler unit 102 by the platform OOM value unit 216. Based on thecomputed S_(platform) value, the entity is categorized as either thebackground entity or the non-background entity. For example, when theS_(platform) value is lower than the predefine threshold (i.e., loadthreshold), the entity is considered as the background entity.Similarly, when computed value of S_(platform) is higher than thepredefined threshold, the entity is considered as the non-backgroundentity.

Further, the OOM Translation unit 218 translates the OOM score to thescheduler understandable format while considering an input from theUpdate Task Statistics unit 220. The input from the Update TaskStatistics unit 220 includes an updated entity structure. The UpdateTask Statistics unit 220 updates entity statistics into structure of theentity based on frequency of execution data from the Task Tick unit 222.

Furthermore, the OOM Translation unit 218 forwards the OOM score (i.e.,which is inform of scheduler understandable format) to the ClusterSelection unit 224. The cluster selection unit 224 selects either thebig-core processor 104 a or the little-core processor 104 b in themulti-core processor system 104 for scheduling the entity based on theOOM score from the OOM Translation unit 218. Further, the ClusterSelection unit 224 receives input from the Per-Task CPU Utilization unit226. The Per-Task CPU Utilization unit 226 tracks the CPU utilization bythe entity based on the input from the CPU metadata unit 228. The CPUmetadata unit 226 tracts CPU utilization or CPU performance of theproposed mechanism.

Further, the cluster selection unit 224 instructs the Core selectionunit 214 to schedule the entity on a little-core processor 104 b whenthe entity is the background entity while considering the loadcontribution of the entity from the Load Calculation unit 208, loadbalance unit 210, and the updated entity statistic from the Update TaskStatistics unit 220. Further, the cluster selection unit 224 instructsthe Core selection unit 214 to schedule the entity on the big-coreprocessor 104 a when the entity is the non-background entity whileconsidering the load contribution of the entity from the LoadCalculation unit 208, and the updated entity statistic from the UpdateTask Statistics unit 220. Further, the IRQ 230 and the RTC 232 influencefrequency of execution of the scheduler 102.

In an embodiment, the background entity is one of the periodic task andthe period service without the user intervention. The periodic task ispersistent and hence requires less processing bandwidth. In an example,the OOM score of the periodic task is −12. Further, the period serviceruns at the default adjustment and having none directly interactivecomponent. In an example, the OOM score of the period service is −16.

FIG. 2b illustrates a communication flow between the multi-coreprocessor system 104 and the scheduler unit 102 for determining whetherthe entity is the IO intensive entity or the non-IO intensive entity,according to an embodiment as disclosed herein. In an embodiment,Completely Fair Queuing (CFQ) IO Scheduler unit 234 is in communicationwith the scheduler unit 102. In an embodiment, an embedded Multi-MediaCard (eMMC) includes a flash memory and a controller in a small ballgrid array (BGA) IC package. In an example, the CFQ is an I/O schedulerfor the Linux kernel. In an embodiment, the CFQ IO Scheduler unit 234includes Block Request Queues unit 236, and IO time calculation unit238.

In an embodiment, the scheduler unit 102 includes Run Queue unit 206,the Load Calculation unit 208, the Load Balance unit 210, the Idle Taskunit 212, the Core selection unit 214, the Cluster Selection unit 224, acalculation unit 240, the CPU metadata unit 228, the Per-Task CPUUtilization unit 226, the Update Task Statistics unit 220, the Task Tickunit 222, the IRQ 230, and the RTC 232.

Further, the scheduler unit 102 detects IO requests of the entity to theeMMC through a block IO subsystem of the operating system installed onthe electronic device 100. Further, the CFQ IO Scheduler unit 234handles IO requests for the block IO subsystem. Further, the CFQ IOScheduler unit 234 dispatches the IO requests according to per-processqueues of the Block Request Queues unit 236 and then allocates timeperiods for each of the process queues to access the storage unit 106 ofthe electronic device 100.

The scheduler unit 102 tracks the request from the entity and computesthe time (by the IO time calculation unit 238) that the entity spends inperforming IO in a pre-defined time period by accumulating time periodsof successive block IO requests. This may be computed as shown inequation (2).

T _(io) =T ₀ +T ₁ +T ₂ . . . T _(N)  (2)

Where T_(io) is the total time the scheduling entity spent in performingIO task in the pre-defined time period, T₀ is the time spent in IORequest 0, T₁ is the time spent in IO Request 1, T₂ is the time spent inIO Request 2, or the like.

Furthermore, sum of execution runtime of the entity provides theexecution time of the entity on the multi-core processor system 104.Thus, a total execution time that the entity spent on the multi-coreprocessor system 104 in the pre-defined time period is accumulated andis represented as T_(exec), for example. Further, the Ø calculation unit240 computes a deciding metric (Φ) as shown in equation (3).

Φ=T _(exec) /T _(io)  (3)

The deciding metric (Φ) is used to categorize the entity as either theIO intensive entity or the non-IO intensive entity based on a logic. Inan embodiment, the logic includes comparing computed value of thedeciding metric (Φ) against an experimentally determined constant.

In an example, consider a scenario where the proposed mechanism isconfigured to schedule the entity from the Run Queue unit 206 in themulti-core processor system 104. Further, the load calculation unit 208tracks the load of the entity and compare with a load threshold (i.e.,detecting that the load contribution of the entity exceeds the loadthreshold). If it is tracked that the load contribution of the entitydoes not exceed the load threshold, then the idle task unit 212 checkswhether the entity is the idle or the entity is not the idle entity. Ifthe entity is the idle, then the scheduler unit 102 considers the entityas low priority for scheduling. If the entity is not the idle and theload contribution of the entity does not exceed the load threshold, thenthe core selection unit 214 selects the Little-core processor 104 b forscheduling the entity. If it is tracked that the load contribution ofthe entity exceeds the load threshold, then the scheduler unit 102 isconfigured to detect whether the entity is the IO intensive entity orthe non-IO intensive entity based on the deciding metric (Φ).

Further, the Ø calculation unit 240 send the deciding metric to thecluster selection unit 216 while considering an input from the UpdateTask Statistics unit 220. The input from the Update Task Statistics unit220 includes an updated entity structure. The Update Task Statisticsunit 220 updates entity statistics into structure of the entity based onfrequency of execution data from the Task Tick unit 222.

The cluster selection unit 224 selects either the big-core processor 104a or the little-core processor 104 b in the multi-core processor system104 for scheduling the entity based on deciding metric (Φ) from the Øcalculation unit 240. Further, the Cluster Selection unit 224 receivesinput from the Per-Task CPU Utilization unit 226. The Per-Task CPUUtilization unit 226 tracks the CPU utilization by the entity based onthe input from the CPU metadata unit 228. The CPU metadata unit 228tracts CPU utilization or CPU performance of the proposed mechanism.Further, the cluster selection unit 224 instructs the Core selectionunit 214 to schedule the entity on a little-core processor 104 b whenthe entity is the IO-intensive entity while considering the loadcontribution of the entity from the Load Calculation unit 208, and theupdated entity statistic from the Update Task Statistics unit 220.Further, the cluster selection unit 224 instructs the Core selectionunit 214 to schedule the entity on the big-core processor 104 a when theentity is the non-IO intensive entity while considering the loadcontribution of the entity from the Load Calculation unit 208, and theupdated entity statistic from the Update Task Statistics unit 226.Further, the IRQ 230 and the RTC 232 influence frequency of execution ofthe scheduler 102.

In an embodiment, a heuristic mechanism is carried out to find theoptimal value of Φ that provided a balance between performance and powerconsumption in the electronic device 100. This may be fine-tuned by auser.

FIG. 3 is a flow diagram illustrating a method 300 for scheduling theentity in the multi-core processor system 104 including the big-coreprocessor 104 a, and the little-core processor 104 b, according to anembodiment as disclosed herein. At step 302, the method 300 includesdetecting that the load contribution of the entity exceeds the loadthreshold. The method 300 allows the scheduler unit 102 to detect thatthe load contribution of the entity exceeds the load threshold.

At step 304, the method 300 includes determining whether the entity isthe background entity, the IO intensive entity, the non-backgroundentity, or the non-IO intensive entity based on at least one parameter.Unlike the conventional methods, the method 300 allows the schedulerunit 102 to determine whether the entity is the background entity, theIO intensive entity, the non-background entity, or the non-IO intensiveentity based on the at least one parameter.

At step 306, the method 300 includes instructing one of to schedule theentity on the little-core processor 104 b when the entity is thebackground entity or the IO intensive entity; and to schedule the entityon the big-core processor 104 a when the entity is the non-backgroundentity or the non-IO intensive entity. Unlike the conventional methods,the method 300 allows the scheduler unit 102 to instruct the multi-coreprocessor system 104 to schedule the entity on the little-core processor104 b when the entity is the background entity or the IO intensiveentity; and to schedule the entity on the big-core processor 104 a whenthe entity is the non-background entity or the non-IO intensive entity.In an embodiment, the parameter includes the OOM Score, the IOTurn-Around-Time, the amount of time that the entity is performing IOtask in the pre-defined time period, the total execution time of theentity in the pre-defined time period, or combination of same. In anembodiment, the background entity is the periodic task or the periodservice without user intervention. Unlike the conventional systems andmethods, the proposed method reduces the migration cost and improves theperformance of the electronic device 100.

The various actions, acts, blocks, steps, or the like in the method 300may be performed in the order presented, in a different order orsimultaneously. Further, in some embodiments, some of the actions, acts,blocks, steps, or the like may be omitted, added, modified, skipped, orthe like without departing from the scope of the invention.

FIG. 4 is a flow diagram illustrating a method 400 for determiningwhether the entity is the background entity, the IO intensive entity,the non-background entity, or the non-IO intensive entity, according toan embodiment as disclosed herein. At step 402, the method 400 includesdetecting that the load contribution of the entity exceeds the loadthreshold. The method 400 allows the scheduler unit 102 to detect thatthe load contribution of the entity exceeds the load threshold.

If it is determined, at step 404, that the load contribution of theentity exceeds the load threshold then, at step 406, the method 400includes instructing to schedule the entity on the little-core processor104 b. The method 400 allows the scheduler unit 102 to instruct themulti-core processor 104 to schedule the entity on the little-coreprocessor 104 b.

If it is determined, at step 404, that the load contribution of theentity does not exceed the load threshold then, at step 408, it isdetermined that the entity is the background entity or the IO intensiveentity based on the at least one parameter then, at step 410, the method400 includes instructing to schedule the entity on the little-coreprocessor 104 b. The method 400 allows the scheduler unit 102 toinstruct the multi-core processor 104 to schedule the entity on thelittle-core processor 104 b. In an embodiment, the parameter includesthe OOM Score, the IO Turn-Around-Time, the amount of time that theentity is performing IO task in the pre-defined time period, the totalexecution time of the entity in the pre-defined time period, orcombination of same. In an embodiment, the background entity is theperiodic task or the period service without user intervention.

If it is determined, at step 408, that the entity is neither thebackground entity nor the IO intensive entity then, at step 412, themethod 400 includes instructing to schedule the entity on the big-coreprocessor 104 a. Unlike the conventional methods, the method 400 allowsthe scheduler unit 102 to instruct to schedule the entity on thebig-core processor 104 a.

The various actions, acts, blocks, steps, or the like in the method 400may be performed in the order presented, in a different order orsimultaneously. Further, in some embodiments, some of the actions, acts,blocks, steps, or the like may be omitted, added, modified, skipped, orthe like without departing from the scope of the invention.

FIG. 5 illustrates a computing environment implementing the method andsystem for scheduling the entity in the multi-core processor system 104including the big-core processor 104 a, and the little-core processor104 b, according to embodiments as disclosed herein. As depicted in thefigure, the computing environment 502 comprises at least one processingunit 516 that is equipped with a control unit 504 and an ArithmeticLogic Unit (ALU) 508, a memory 512, a storage unit 514, plurality ofnetworking devices 506 and a plurality Input output (I/O) devices 510.The processing unit 516 is responsible for processing the instructionsof the schemes. The processing unit 516 receives commands from thecontrol unit 504 in order to perform its processing. Further, anylogical and arithmetic operations involved in the execution of theinstructions are computed with the help of the ALU 508.

The overall computing environment 502 can be composed of multiplehomogeneous or heterogeneous cores, multiple CPUs of different kinds,special media and other accelerators. The processing unit 516 isresponsible for processing the instructions of the schemes. Further, theplurality of processing units 516 may be located on a single chip orover multiple chips.

The scheme comprising of instructions and codes required for theimplementation are stored in either the memory unit 512 or the storage514 or both. At the time of execution, the instructions may be fetchedfrom the corresponding memory 512 or storage 514, and executed by theprocessing unit 516.

In case of any hardware implementations various networking devices 506or external I/O devices 510 may be connected to the computingenvironment to support the implementation through the networking unitand the I/O device unit.

The embodiments disclosed herein can be implemented through at least onesoftware program running on at least one hardware device and performingnetwork management functions to control the elements. The elements shownin the FIGS. 1 through 5 include blocks which can be at least one of ahardware device, or a combination of hardware device and software units.

The foregoing description of the specific embodiments will so fullyreveal the general nature of the embodiments herein that others can, byapplying current knowledge, readily modify or adapt for variousapplications such specific embodiments without departing from thegeneric concept, and, therefore, such adaptations and modificationsshould and are intended to be comprehended within the meaning and rangeof equivalents of the disclosed embodiments. It is to be understood thatthe phraseology or terminology employed herein is for the purpose ofdescription and not of limitation. Therefore, while the embodimentsherein have been described in terms of preferred embodiments, thoseskilled in the art will recognize that the embodiments herein can bepracticed with modification within the spirit and scope of theembodiments as described herein.

1. A method for scheduling an entity in a multi-core processor systemincluding a big-core processor, and a little-core processor, comprising:detecting, by a scheduler, that a load contribution of the entityexceeds a load threshold; determining, by the scheduler, whether theentity is one of a background entity, an IO intensive entity, anon-background entity, and an non-IO intensive entity based on at leastone parameter; and instructing, by the scheduler, one of to schedule theentity on a little-core processor when the entity is at least one of thebackground entity and the IO intensive entity; and to schedule theentity on the big-core processor when the entity is at least one of thenon-background entity and the non-IO intensive entity.
 2. The method ofclaim 1, wherein the parameter comprises at least one of anOut-of-Memory (OOM) Score, a IO Turn-Around-Time, and an amount of timethat the entity is performing IO task in a pre-defined time period, anda total execution time of the entity in the pre-defined time period. 3.The method of claim 1, wherein the background entity is one of aperiodic task and a period service without user intervention.
 4. Anelectronic device for scheduling an entity, the electronic devicecomprising: a memory; a multi-core processor system comprising abig-core processor, and a little-core processor coupled to said memory:and a scheduler coupled to the multi-core processor system, wherein saidscheduler is configured to: detect that a load contribution of theentity exceeds a load threshold; determine whether the entity is one ofa foreground entity, a background entity, a CPU intensive entity, and anIO intensive entity based on at least one parameter; and instruct one ofto schedule the entity on a little-core processor when the entity is atleast one of the background entity and the IO intensive entity; and toschedule the entity on the big-core processor when the entity is atleast one of the non-background entity and the non-IO intensive entity.5. The electronic device of claim 4, wherein the parameter comprises atleast one of an Out-of-Memory (OOM) Score, a IO Turn-Around-Time, and anamount of time that the entity is performing IO in a pre-defined timeinterval, and a total execution time of the entity in the pre-definedtime slice.
 6. The electronic device of claim 4, wherein the backgroundentity is one of a periodic task and a period service without userintervention.
 7. A computer program product comprising computerexecutable program code recorded on a computer readable non-transitorystorage medium, the computer executable program code when executedcausing the actions including: detecting, by a scheduler, that a loadcontribution of an entity exceeds a load threshold; determining, by thescheduler, whether the entity is one of a foreground entity, abackground entity, a CPU intensive entity, and an IO intensive entitybased on at least one parameter; and instructing, by the scheduler, oneof to schedule the entity on a little-core processor when the entity isat least one of the background entity and the IO intensive entity; andto schedule the entity on the big-core processor when the entity is atleast one of the non-background entity and the non-IO intensive entity.8. The method of claim 1, wherein the entity is at least one of a task,a thread and a data flow.
 9. The method of claim 1, wherein thedetecting comprises: when the load contribution of the entity does notexceed the load threshold, determining whether the entity is an idleentity or not.
 10. The method of claim 9, further comprises: consideringthe entity as low priority for scheduling in response to a determinationthat the entity is the idle entity; and selecting the little coreprocessor for scheduling the entity in response to a determination thatthe entity is not the idle entity.
 11. The method of claim 2, whereinthe OOM score is used to categorize the entity as either the backgroundentity or the non-background entity.
 12. The electronic device of claim4, wherein the entity is at least one of a task, a thread and a dataflow.
 13. The electronic device of claim 4, wherein the scheduler isfurther configured to determine whether the entity is an idle entity ornot when the load contribution of the entity does not exceed the loadthreshold.
 14. The electronic device of claim 13, wherein the scheduleris further configured to: consider the entity as low priority forscheduling in response to a determination that the entity is the idleentity; and select the little core processor for scheduling the entityin response to a determination that the entity is not the idle entity.15. The electronic device of claim 5, wherein the OOM score is used tocategorize the entity as either the background entity or thenon-background entity.